﻿using System;
using System.Collections.Generic;
using System.Linq;
using Iacym.Entities;
using System.Data.Objects;

namespace Iacym.Repository
{
    public class OfrendaRepository : MasterRepository, IOfrendaRepository
    {
        public List<OFRENDA> GetAllFromOfrendas()
        {
            var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                        select p;
            ObjectContext.Refresh(RefreshMode.StoreWins, query);
            return query.ToList();
        }

        public OFRENDA GetOfrendaById(int id)
        {
            var query = from p in context.OFRENDAs
                        where p.Id.Equals(id)
                        select p;
            ObjectContext.Refresh(RefreshMode.StoreWins, query);
            return query.SingleOrDefault();
        }

        public void AddOfrenda(OFRENDA ofrenda)
        {
            ofrenda.PERSONA = null;
            ofrenda.TIPO_MONEDA = null;
            ofrenda.TIPO_OFRENDA = null;
            ofrenda.TIPO_PAGO = null;
            ofrenda.TIPO_REUNION = null;
            context.OFRENDAs.Add(ofrenda);
            context.SaveChanges();
        }

        public void UpdateOfrenda(OFRENDA ofrenda)
        {
            context.Entry(ofrenda.PERSONA).State = System.Data.EntityState.Unchanged;
            context.Entry(ofrenda).State = System.Data.EntityState.Modified;
            context.SaveChanges();
        }    

        #region Busquedas

        public List<OFRENDA> GetFromOfrendasByPersona(string criterio)
        {
            if (criterio != string.Empty)
            {
                var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                            where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                            || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                            || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                            || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                            || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                            || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                            || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                            || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                            || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                            || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                            select p;

                return query.ToList();
            }
            else
            {
                var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                            select p;

                return query.ToList();
            }
        }

        #region Ofrendas por tipo ofrenda y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaPersona(int tipoOfrenda, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaPersonaFechaEspec(int tipoOfrenda, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaPersonaRangoFechas(int tipoOfrenda, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(tipoOfrenda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo ofrenda, tipo moneda y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoMonedaPersona(int TO, int TM, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoMonedaPersonaFechaEspec(int TO, int TM, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoMonedaPersonaRangoFechas(int TO, int TM, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo ofrenda, tipo pago y fechas + persona

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoPersona(int TO, int TP, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoPersonaFechaEspec(int TO, int TP, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoPersonaRangoFechas(int TO, int TP, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo ofrenda, tipo pago, tipo monenda y fechas + persona

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoTipoMonedaPersona(int TO, int TP, int TM, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoTipoMonedaPersonaFechaEspec(int TO, int TP, int TM, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoOfrendaTiPoPagoTipoMonedaPersonaRangoFechas(int TO, int TP, int TM, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO)
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo moneda y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoMonedaPersona(int tipoMoneda, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoMonedaPersonaFechaEspec(int tipoMoneda, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoMonedaPersonaRangoFechas(int tipoMoneda, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(tipoMoneda)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo pago y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoPagoPersona(int tipoPago, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(tipoPago)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoPagoPersonaFechaEspec(int tipoPago, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(tipoPago)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTipoPagoPersonaRangoFechas(int tipoPago, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(tipoPago)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Busqueda de ofrendas solo por fechas

        public List<OFRENDA> GetFromOfrendaByPersonaFechaEspec(string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByPersonaRangoFechas(string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
            }
            
        }

        #endregion

        #region Ofrendas por tipo moneda, tipo pago, personas y fechas

        public List<OFRENDA> GetFromOfrendaByTiPoPagoTipoMonedaPersona(int TP, int TM, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTiPoPagoTipoMonedaPersonaFechaEspec(int TP, int TM, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }

        public List<OFRENDA> GetFromOfrendaByTiPoPagoTipoMonedaPersonaRangoFechas(int TP, int TM, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP)
                                && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }
            
        }
        
        #endregion

        #region Ofrendas por tipo de reunion y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoReunionPersona(int tipoReunion, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(tipoReunion)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionPersonaFechaEspec(int tipoReunion, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionPersonaRangoFechas(int tipoReunion, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(tipoReunion)
                                select p;

                    return query.ToList();
                }
            }

        }

        #endregion

        #region Ofrendas por tipo de reunion, tipo ofrenda y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaPersona(int TR, int TO, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaPersonaFechaEspec(int TR, int TO, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaPersonaRangoFechas(int TR, int TO, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        #endregion

        #region Ofrendas por tipo de reunion, tipo pago y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoPagoPersona(int TR, int TP, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoPagoPersonaFechaEspec(int TR, int TP, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoPagoPersonaRangoFechas(int TR, int TP, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        #endregion

        #region Ofrendas por tipo de reunion, tipo moneda y fechas + Persona

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoMonedaPersona(int TR, int TM, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoMonedaPersonaFechaEspec(int TR, int TM, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoMonedaPersonaRangoFechas(int TR, int TM, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_MONEDA.Id.Equals(TM) && p.TIPO_REUNION.Id.Equals(TR)
                                select p;

                    return query.ToList();
                }
            }

        }

        #endregion

        #region Ofrendas por tipo de reunion, tipo ofrenda, tipo pago, tipo moneda y fechas + Personas

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaTiPoPagoTipoMonedaPersona(int TR, int TO, int TP, int TM, string criterio, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaTiPoPagoTipoMonedaPersonaFechaEspec(int TR, int TO, int TP, int TM, string criterio, DateTime fecha, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) 
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) 
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) == fecha.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) == fecha.Date && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) 
                                && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }

        }

        public List<OFRENDA> GetFromOfrendaByTipoReunionTipoOfrendaTiPoPagoTipoMonedaPersonaRangoFechas(int TR, int TO, int TP, int TM, string criterio, DateTime fechaIni, DateTime fechaFin, int opc)
        {
            if (opc == 1) //Vigentes
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == false
                                select p;

                    return query.ToList();
                }
            }
            else if (opc == 2) // Anulados
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && p.Anulado == true
                                select p;

                    return query.ToList();
                }
            }
            else // Todos
            {
                if (criterio != string.Empty)
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where (p.PERSONA.ApeMaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.ApePaterno.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Nombres.ToUpper().Contains(criterio.ToUpper())
                                || p.PERSONA.Dni.ToUpper().Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.Nombres.ToUpper() + " " + p.PERSONA.ApePaterno.ToUpper()).Contains(criterio.ToUpper())
                                || (p.PERSONA.ApePaterno.ToUpper() + " " + p.PERSONA.ApeMaterno.ToUpper() + " " + p.PERSONA.Nombres).Contains(criterio.ToUpper()))
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                && EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                select p;

                    return query.ToList();
                }
                else
                {
                    var query = from p in context.OFRENDAs.Include("TIPO_MONEDA").Include("TIPO_OFRENDA").Include("TIPO_PAGO").Include("TIPO_REUNION").Include("PERSONA")
                                where EntityFunctions.TruncateTime(p.Fecha) >= fechaIni.Date && EntityFunctions.TruncateTime(p.Fecha) <= fechaFin.Date
                                && p.TIPO_REUNION.Id.Equals(TR) && p.TIPO_OFRENDA.Id.Equals(TO) && p.TIPO_PAGO.Id.Equals(TP) && p.TIPO_MONEDA.Id.Equals(TM)
                                select p;

                    return query.ToList();
                }
            }

        }

        #endregion

        #endregion
    }
}
